﻿
import BasicGeometry from './BasicGeometry.js';

/**
*
* :
*
*                       -----width----+(width/2,height/2)
*                       |             |
*                       |    (0,0)    |
*                       |      +    height
*                       |             |
*                       |             |
*                        +----width-----
*        (-width/2,-height/2)
*    
*@param {Number}width
*@param {Number}height
*@param {Number}widthSegments
*@param {Number}heightSegments
*@constructor
*@memberof Cesium
*/
function PlaneBufferGeometry(width, height, widthSegments, heightSegments) {
    this.width = width;
    this.height = height;
    this.widthSegments = widthSegments;
    this.heightSegments = heightSegments;

}

/**
*
*@param {}
*/
PlaneBufferGeometry.createGeometry = function (planeBufferGeometry) {

    var width = planeBufferGeometry.width,
        height = planeBufferGeometry.height,
        widthSegments = planeBufferGeometry.widthSegments,
        heightSegments = planeBufferGeometry.heightSegments;


    width = width || 1;
    height = height || 1;

    var width_half = width / 2;
    var height_half = height / 2;

    var gridX = Math.floor(widthSegments) || 1;
    var gridY = Math.floor(heightSegments) || 1;

    var gridX1 = gridX + 1;
    var gridY1 = gridY + 1;

    var segment_width = width / gridX;
    var segment_height = height / gridY;

    var ix, iy;

    // buffers

    var indices = [];
    var vertices = [];
    var normals = [];
    var uvs = [];

    // generate vertices, normals and uvs

    for (iy = 0; iy < gridY1; iy++) {

        var y = iy * segment_height - height_half;

        for (ix = 0; ix < gridX1; ix++) {

            var x = ix * segment_width - width_half;

            vertices.push(x, -y, 0);

            normals.push(0, 0, 1);

            uvs.push(ix / gridX);
            uvs.push(1 - (iy / gridY));

        }

    }

    // indices

    for (iy = 0; iy < gridY; iy++) {

        for (ix = 0; ix < gridX; ix++) {

            var a = ix + gridX1 * iy;
            var b = ix + gridX1 * (iy + 1);
            var c = (ix + 1) + gridX1 * (iy + 1);
            var d = (ix + 1) + gridX1 * iy;

            // faces

            indices.push(a, b, d);
            indices.push(b, c, d);

        }

    }

    var geom = BasicGeometry.createGeometry({
        positions: new Float32Array(vertices),
        normals: new Float32Array(normals),
        uvs: new Float32Array(uvs),
        indices: new Int32Array(indices)
    })

    return geom;
}

export default PlaneBufferGeometry; 